package com.neuedu.his.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.neuedu.his.po.Medicalrecord;
import com.neuedu.his.service.MedicalrecordService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

/**
 * 病历管理控制器
 * 处理病历的查询、暂存、提交等操作
 */
@RestController
@RequestMapping("/api/medical-records")
public class MedicalrecordController {

    // 日志记录器
    private static final Logger log = LoggerFactory.getLogger(MedicalrecordController.class);

    // 注入病历服务
    @Autowired
    private MedicalrecordService medicalRecordService;

    /**
     * 根据病历号获取患者病历
     * @param caseNumber 病历号
     * @return 包含病历信息的响应实体
     */
//    @GetMapping("/{caseNumber}")
//    public ResponseEntity<Medicalrecord> getMedicalRecord(@PathVariable String caseNumber) {
//        try {
//            // 校验病历号参数
//            if (caseNumber == null || caseNumber.isEmpty()) {
//                log.warn("获取病历失败：病历号为空");
//                return ResponseEntity.badRequest().build();
//            }
//
//            // 构建查询条件
//            QueryWrapper<Medicalrecord> wrapper = new QueryWrapper<>();
//            wrapper.eq("caseNumber", caseNumber);
//            Medicalrecord record = medicalRecordService.getOne(wrapper);
//
//            // 处理未找到记录的情况
//            if (record == null) {
//                log.info("获取病历：未找到记录，病历号={}", caseNumber);
//                return ResponseEntity.ok(new Medicalrecord());
//            }
//
//            // 返回查询到的病历
//            log.info("获取病历成功，病历号={}", caseNumber);
//            return ResponseEntity.ok(record);
//        } catch (Exception e) {
//            // 处理异常情况
//            log.error("获取病历异常，病历号={}", caseNumber, e);
//            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
//        }
//    }

    /**
     * 统一保存病历接口（支持暂存和提交功能）
     * @param record 病历实体对象
     * @return 包含处理结果的响应实体
     */

    @PostMapping("/save")
    public ResponseEntity<?> saveRecord(@RequestBody Medicalrecord record) {
        try {
            // 校验参数有效性
            if (record == null || record.getCasenumber() == null || record.getCasenumber().isEmpty()) {
                log.warn("保存病历失败：参数无效，record={}", record);
                return ResponseEntity.badRequest().build();
            }

            // 处理状态默认值（未指定状态时默认暂存）
            if (record.getCasestate() == null) {
                record.setCasestate(1); // 1-暂存状态
            }

            // 提交状态时校验必填字段
            if (record.getCasestate() == 2 && (record.getReadme() == null || record.getReadme().isEmpty())) {
                log.warn("提交病历失败：主诉为空，病历号={}", record.getCasenumber());
                return ResponseEntity.badRequest().body("主诉不能为空");
            }

            // 保存或更新病历
            medicalRecordService.saveOrUpdate(record);
            log.info("保存病历成功，病历号={}，状态={}", record.getCasenumber(), record.getCasestate());
            return ResponseEntity.ok(record);
        } catch (Exception e) {
            // 处理异常情况
            log.error("保存病历异常，record={}", record, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    /**
     * 暂存病历（专用接口）
     * @param caseNumber 病历号
     * @param record 病历实体对象
     * @return 包含处理结果的响应实体
     */
    @PostMapping("/{caseNumber}/draft")
    public ResponseEntity<Void> saveDraft(
            @PathVariable String caseNumber,
            @RequestBody Medicalrecord record) {
        try {
            // 校验参数有效性
            if (caseNumber == null || caseNumber.isEmpty() || record == null) {
                log.warn("暂存病历失败：参数无效，病历号={}，record={}", caseNumber, record);
                return ResponseEntity.badRequest().build();
            }

            // 设置病历号和状态（暂存）
            record.setCasenumber(caseNumber);
            record.setCasestate(1); // 1-暂存状态
            medicalRecordService.saveOrUpdate(record);

            log.info("暂存病历成功，病历号={}", caseNumber);
            return ResponseEntity.ok().build();
        } catch (Exception e) {
            // 处理异常情况
            log.error("暂存病历异常，病历号={}", caseNumber, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    /**
     * 提交病历（专用接口）
     * @param caseNumber 病历号
     * @param record 病历实体对象
     * @return 包含处理结果的响应实体
     */
    @PostMapping("/{caseNumber}/submit")
    public ResponseEntity<?> submitRecord(
            @PathVariable String caseNumber,
            @RequestBody Medicalrecord record) {
        try {
            // 校验参数有效性
            if (caseNumber == null || caseNumber.isEmpty() || record == null) {
                log.warn("提交病历失败：参数无效，病历号={}，record={}", caseNumber, record);
                return ResponseEntity.badRequest().build();
            }

            // 校验必填字段（主诉）
            if (record.getReadme() == null || record.getReadme().isEmpty()) {
                log.warn("提交病历失败：主诉为空，病历号={}", caseNumber);
                return ResponseEntity.badRequest().body("主诉不能为空");
            }

            // 设置病历号和状态（已提交）
            record.setCasenumber(caseNumber);
            record.setCasestate(2); // 2-已提交状态
            medicalRecordService.saveOrUpdate(record);

            log.info("提交病历成功，病历号={}", caseNumber);
            return ResponseEntity.ok(record);
        } catch (Exception e) {
            // 处理异常情况
            log.error("提交病历异常，病历号={}", caseNumber, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
    @GetMapping
    public ResponseEntity<Medicalrecord> getMedicalRecord(@RequestParam String casenumber) {
        try {
            // 打印接收到的参数，便于排查格式问题
            log.info("收到获取病历请求，casenumber={}", casenumber);

            // 仅校验非空，不限制格式（除非有明确业务规则）
            if (casenumber == null || casenumber.trim().isEmpty()) {
                log.warn("获取病历失败：casenumber为空");
                return ResponseEntity.badRequest().body(null); // 返回空body而非build()
            }

            QueryWrapper<Medicalrecord> wrapper = new QueryWrapper<>();
            // 确保字段名与数据库表一致（例如数据库字段是casenumber）
            wrapper.eq("casenumber", casenumber.trim());

            Medicalrecord record = medicalRecordService.getOne(wrapper);

            if (record == null) {
                log.info("未找到病历记录，casenumber={}", casenumber);
                return ResponseEntity.ok(new Medicalrecord()); // 返回空对象
            }

            log.info("获取病历成功，casenumber={}", casenumber);
            return ResponseEntity.ok(record);
        } catch (Exception e) {
            log.error("获取病历异常，casenumber={}", casenumber, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
}